import org.junit.Test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @auther yangdong
 * @create 2020-05-16
 *1.泛型的声明
 * interface List<T> 和 class GenTest<K,V>
 * 其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。
 * 常用T表示，是Type的缩写。
 * 2.泛型的实例化：
 * 一定要在类名后面指定类型参数的值（类型）。如：
 * List<String> strList = new ArrayList<String>();
 * Iterator<Customer> iterator = customers.iterator();
 *  T只能是类，不能用基本数据类型填充。但可以使用包装类填充
 *  把一个集合中的内容限制为一个特定的数据类型，这就是generics背后
 * 的核心思想
 * 使用泛型的主要优点是能够在编译时而不是在运行时检测错误。
 * 1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
 * <E1,E2,E3>
 * 2. 泛型类的构造器如下：public GenericClass(){}。
 * 而下面是错误的：public GenericClass<E>(){}
 * 3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
 * 4. 泛型不同的引用不能相互赋值。
 * >尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有
 * 一个ArrayList被加载到JVM中。
 * 5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价
 * 于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
 * 6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
 * 7. jdk1.7，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();
 * 8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
 *
 * 9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态
 * 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法
 * 中不能使用类的泛型。
 * 10. 异常类不能是泛型的
 * 11. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
 * 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
 * 12.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
 *  子类不保留父类的泛型：按需实现
 *  没有类型 擦除
 *  具体类型
 *  子类保留父类的泛型：泛型子类
 *  全部保留
 *  部分保留
 * 结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自
 * 己的泛型
 *
 * 如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的
 * 类或接口，G<B>并不是G<A>的子类型！
 * 比如：String是Object的子类，但是List<String >并不是List<Object>
 * 的子类。
 */
public class GnericTest {
    /**
     * 1.使用类型通配符：？
     * 比如：List<?> ，Map<?,?>
     * List<?>是List<String>、List<Object>等各种泛型List的父类。
     * 2.读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型
     * 是什么，它包含的都是Object。
     * 3.写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中
     * 添加对象。
     *  唯一的例外是null，它是所有类型的成员。
     *  将任意元素加入到其中不是类型安全的：
     * Collection<?> c = new ArrayList<String>();
     * c.add(new Object()); // 编译时错误
     * 因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集
     * 合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知
     * 道那是什么类型，所以我们无法传任何东西进去。
     *  唯一的例外的是null，它是所有类型的成员。
     *  另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的
     * 类型，但是我们知道，它总是一个Object。
     *
     *  <?>
     * 允许所有泛型的引用调用
     *  通配符指定上限
     * 上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
     *  通配符指定下限
     * 下限super：使用时指定的类型不能小于操作的类，即>=
     *  举例：
     *  <? extends Number> (无穷小 , Number]
     * 只允许泛型为Number及Number子类的引用调用
     *  <? super Number> [Number , 无穷大)
     * 只允许泛型为Number及Number父类的引用调用
     *  <? extends Comparable>
     * 只允许泛型为实现Comparable接口的实现类的引用调用
     * //注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
     * public static <?> void test(ArrayList<?> list){
     * }
     * //注意点2：编译错误：不能用在泛型类的声明上
     * class GenericTypeClass<?>{
     * }
     * //注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
     * ArrayList<?> list2 = new ArrayList<?>();
     * @param list
     */
    public void print(List<?> list){
        Iterator<?> i=list.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
    }
    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");

        order1.setOrderT("AA:hello");

    }

    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        sub1.setOrderT(1122);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("order2...");
    }

    @Test
    public void test3(){

        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        ArrayList<Object> list3 = new ArrayList<>();
        print(list2);
        print(list3);
        /**
         * List<?>是List<String>、List<Object>等各种泛型List的父类。
         *      * 2.读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型
         *      * 是什么，它包含的都是Object。
         *      * 3.写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中
         *      * 添加对象。
         *      *  唯一的例外是null，它是所有类型的成员。
         *
         *        将任意元素加入到其中不是类型安全的：
         *      * Collection<?> c = new ArrayList<String>();
         *      * c.add(new Object()); // 编译时错误
         *      * 因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集
         *      * 合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知
         *      * 道那是什么类型，所以我们无法传任何东西进去。
         *      *  唯一的例外的是null，它是所有类型的成员。
         *      *  另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的
         *      * 类型，但是我们知道，它总是一个Object。
         */
        List<?> list4=new ArrayList<>();
        list3.add("lily");
        list4=list3;
        //list4.add("aa");编译错误
        list4.add(null);
        System.out.println(list4.get(0));
        //如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的
        // * 类或接口，G<B>并不是G<A>的子类型！
        // * 比如：String是Object的子类，但是List<String >并不是List<Object>
        // * 的子类。不能进行强转
        // list3=list2
        //泛型不同的引用不能相互赋值。
//        list1 = list2;

    }

    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }
    @Test
    public void Test5(){
        StudentDAO sd=new StudentDAO();
        sd.add(new Student("lily",12));
        sd.add(new Student("lucy",13));
        sd.add(new Student("lilei",14));
        List<Map<Integer,Student>> list=sd.show();
        System.out.println(list);
        /**
         *  <?>
         *      * 允许所有泛型的引用调用
         *      *  通配符指定上限
         *      * 上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
         *      *  通配符指定下限
         *      * 下限super：使用时指定的类型不能小于操作的类，即>=
         *
         *       <? extends Number> (无穷小 , Number]
         *      * 只允许泛型为Number及Number子类的引用调用
         *
         *       <? super Number> [Number , 无穷大)
         *      * 只允许泛型为Number及Number父类的引用调用
         */
        List<? extends Father> list0=null;
        List<? super Father> list1=null;
        List<Father> list2=null;
        List<Son1> list3=null;
        List<Object> list4=null;
        list0=list2;
        list0=list3;
        //list=list4;编译不通过
        list1=list2;
        //list1=list3;编译不通过
        list1=list4;
    }
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

